﻿
using UdonSharp;
using UnityEngine;
using VRC.SDKBase;
using VRC.Udon;

/// <summary>
/// 闪烁曲线类型枚举 - 定义不同的闪烁效果样式（必须在类外部声明）
/// </summary>
public enum FlashCurveType
{
    Smooth,     // 平滑闪烁 - 渐变式明暗变化
    Sharp,      // 尖锐闪烁 - 快速开关式变化  
    Pulse,      // 脉冲闪烁 - 心跳式律动效果
    Wave        // 波浪闪烁 - 波浪式起伏变化
}

/// <summary>
/// 伊卡洛斯交互系统 - 复杂的多功能交互控制器
/// 功能包括：光源闪烁效果、红光警告、音频播放、贴图移动、玩家碰撞检测等
/// 可作为开关触发各种视觉和听觉效果，适用于游戏中的特殊事件或危险区域
/// </summary>
public class Icarus : UdonSharpBehaviour
{
    // ================================ 光源基础设置 ================================
    [Header("光源设置")]
    [Tooltip("目标光源数组 - 将需要控制闪烁效果的Light组件拖拽到此数组中，支持多个光源同时控制")]
    public Light[] targetLights;
    
    // ================================ 闪烁效果设置 ================================
    [Header("闪烁设置")]
    [Tooltip("闪烁持续时间最小值 - 每次闪烁效果持续的最短时间（秒），实际时间会在最小和最大值之间随机选择")]
    [Range(2f, 4f)]
    public float flashDurationMin = 2f;
    
    [Tooltip("闪烁持续时间最大值 - 每次闪烁效果持续的最长时间（秒），与最小值一起构成随机时间范围")]
    [Range(2f, 4f)]
    public float flashDurationMax = 4f;
    
    [Tooltip("强度倍数 - 闪烁时光源亮度相对于原始亮度的倍数，数值越大闪烁越明显")]
    [Range(1f, 15f)]
    public float intensityMultiplier = 8f;
    
    [Tooltip("闪烁频率 - 每秒内的闪烁次数，控制闪烁的快慢节奏，数值越大闪烁越频繁")]
    [Range(5f, 30f)]
    public float flashFrequency = 15f;
    
    [Tooltip("随机变化强度 - 为闪烁添加随机因素使效果更自然，0为完全规律，1为完全随机")]
    [Range(0f, 1f)]
    public float randomnessIntensity = 0.8f;
    
    [Tooltip("闪烁曲线类型 - 选择不同的闪烁模式：Smooth=平滑渐变，Sharp=快速开关，Pulse=脉冲心跳，Wave=波浪起伏")]
    public FlashCurveType flashCurveType = FlashCurveType.Sharp;
    
    [Header("等待和红色灯光设置")]
    [Tooltip("闪烁完成后等待时间范围（秒）")]
    [Range(8f, 20f)]
    public float waitTimeMin = 8f;
    
    [Range(8f, 20f)]
    public float waitTimeMax = 20f;
    
    [Tooltip("红色灯光强度倍数（相对于原始强度）")]
    [Range(1f, 10f)]
    public float redLightIntensityMultiplier = 2f;
    
    [Tooltip("红色灯光颜色")]
    public Color redLightColor = Color.red;
    
    [Tooltip("红色灯光持续时间（秒）")]
    [Range(1f, 30f)]
    public float redLightDuration = 10f;
    
    [Tooltip("是否启用等待和红色灯光功能")]
    public bool enableWaitAndRedLight = true;
    
    [Header("音频设置")]
    [Tooltip("闪烁时播放的音频源")]
    public AudioSource flashAudioSource;
    
    [Tooltip("红色灯光时播放的音频源（使用相同设置）")]
    public AudioSource redLightAudioSource;
    
    [Tooltip("是否启用音频播放")]
    public bool enableAudio = true;
    
    [Tooltip("音频音量")]
    [Range(0f, 2f)]
    public float audioVolume = 1.2f;
    
    [Tooltip("音频是否循环播放")]
    public bool loopAudio = true;
    
    [Tooltip("音频淡入时间（秒）")]
    [Range(0f, 2f)]
    public float audioFadeInTime = 0.5f;
    
    [Tooltip("音频淡出时间（秒）")]
    [Range(0f, 2f)]
    public float audioFadeOutTime = 1f;
    
    [Tooltip("音源最大听音范围（米）")]
    [Range(1f, 50f)]
    public float audioMaxDistance = 10f;
    
    [Tooltip("是否显示音源范围可视化")]
    public bool showAudioRange = true;
    
    // ================================ 交互开关设置 ================================
    [Header("开关设置")]
    [Tooltip("启用点击交互 - 是否允许玩家通过点击来触发此系统")]
    public bool enableClickInteraction = true;
    
    [Tooltip("单次使用限制 - 是否只允许触发一次，用于创建一次性事件或重要机关")]
    public bool singleUseOnly = false;
    
    [Tooltip("点击冷却时间 - 两次点击之间的最小间隔时间（秒），防止误触或快速连击")]
    [Range(0.1f, 5f)]
    public float clickCooldown = 1f;
    
    // ================================ 贴图移动系统设置 ================================
    [Header("贴图移动系统")]
    [Tooltip("移动贴图对象 - 需要移动的GameObject，通常是一个带有贴图的平面或立方体")]
    public GameObject movingTexture;
    
    [Tooltip("移动路径点 - 贴图移动的路线点数组，贴图将按顺序访问这些点")]
    public Transform[] pathPoints;
    
    [Tooltip("移动速度 - 贴图移动的速度（米/秒），影响移动的快慢")]
    [Range(1f, 50f)]
    public float textureMoveSpeed = 15f;
    
    [Tooltip("碰撞检测范围 - 检测玩家与移动贴图碰撞的距离范围（米）")]
    [Range(0.1f, 5f)]
    public float textureCollisionRadius = 1f;
    
    [Tooltip("启用贴图移动 - 是否激活贴图移动功能")]
    public bool enableTextureMovement = true;
    
    [Tooltip("移动调试信息 - 是否在控制台显示贴图移动的详细调试信息")]
    public bool showTextureDebugInfo = true;
    
    [Tooltip("生命值系统引用 - 将场景中的WorldHealth组件拖拽到此处，用于碰撞时杀死玩家")]
    public WorldHealth worldHealthReference;
    

    
    [Header("调试设置")]
    [Tooltip("是否启用调试日志")]
    public bool enableDebugLog = true;
    
    // 私有变量
    private float[] originalIntensities;
    private Color[] originalColors; // 保存原始颜色
    private bool isFlashing = false;
    private bool hasBeenUsed = false;
    private float flashStartTime = 0f;
    private float lastClickTime = 0f;
    private bool isInitialized = false;
    private float currentFlashDuration = 0f; // 当前随机持续时间
    
    // 等待和红色灯光相关变量
    private bool isWaitingForRedLight = false;
    private float waitStartTime = 0f;
    private float currentWaitDuration = 0f;
    private bool isRedLightActive = false;
    private float redLightStartTime = 0f;
    
    // 每个光源的独立闪烁状态
    private bool[] lightFlashingStates; // 每个光源是否在闪烁
    private float[] lightFlashStartTimes; // 每个光源的闪烁开始时间
    private float[] lightFlashDurations; // 每个光源的闪烁持续时间
    private float[] lightRandomOffsets; // 每个光源的随机偏移
    private float[] lightRandomSpeeds; // 每个光源的随机速度
    private float[] lightRandomPhases; // 每个光源的随机相位
    private float[] lightIndividualFrequencies; // 每个光源的独立频率
    
    // 音频相关变量
    private bool isAudioPlaying = false;
    private float audioStartTime = 0f;
    private float audioFadeStartTime = 0f;
    private bool isAudioFadingOut = false;
    private float originalAudioVolume = 0f;
    private bool audioInitialized = false;
    
    // 红色灯光音频相关变量
    private bool isRedLightAudioPlaying = false;
    private float redLightAudioStartTime = 0f;
    private float redLightAudioFadeStartTime = 0f;
    private bool isRedLightAudioFadingOut = false;
    private float originalRedLightAudioVolume = 0f;
    private bool redLightAudioInitialized = false;
    
    // 贴图移动系统相关变量
    private bool isTextureMoving = false;
    private int currentPathIndex = 0;
    private Vector3 textureStartPosition;
    private bool textureMovementInitialized = false;
    private bool hasKilledPlayer = false; // 标记是否已经杀死过玩家
    private bool isTextureStarted = false; // 标记贴图是否已经开始移动
    

    
    void Start()
    {
        InitializeLightSystem();
        
        // 检查音源设置
        if (enableAudio && flashAudioSource != null)
        {
            CheckAndFixAudioSource();
            
            // 确保音源在开始时是停止状态
            if (flashAudioSource.isPlaying)
            {
                flashAudioSource.Stop();
                if (enableDebugLog)
                {
                    Debug.LogWarning("[Icarus] 检测到闪烁音源在开始时正在播放，已强制停止");
                }
            }
        }
        
        // 检查红色灯光音源设置
        if (enableAudio && redLightAudioSource != null)
        {
            CheckAndFixRedLightAudioSource();
            
            // 确保红色灯光音源在开始时是停止状态
            if (redLightAudioSource.isPlaying)
            {
                redLightAudioSource.Stop();
                if (enableDebugLog)
                {
                    Debug.LogWarning("[Icarus] 检测到红色灯光音源在开始时正在播放，已强制停止");
                }
            }
        }
    }
    
    void Update()
    {
        if (isFlashing)
        {
            UpdateFlashAnimation();
        }
        
        // 更新等待和红色灯光状态
        UpdateWaitAndRedLight();
        
        // 更新音频播放
        UpdateAudio();
        UpdateRedLightAudio();
        
        // 更新贴图移动
        UpdateTextureMovement();
    }
    
    /// <summary>
    /// 初始化光源系统
    /// </summary>
    void InitializeLightSystem()
    {
        if (targetLights == null || targetLights.Length == 0)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 没有分配光源！请在Inspector中分配光源组件");
            }
            return;
        }
        
        // 保存原始光源设置
        originalIntensities = new float[targetLights.Length];
        originalColors = new Color[targetLights.Length]; // 保存原始颜色
        lightFlashingStates = new bool[targetLights.Length];
        lightFlashStartTimes = new float[targetLights.Length];
        lightFlashDurations = new float[targetLights.Length];
        lightRandomOffsets = new float[targetLights.Length];
        lightRandomSpeeds = new float[targetLights.Length];
        lightRandomPhases = new float[targetLights.Length];
        lightIndividualFrequencies = new float[targetLights.Length];
        
        for (int i = 0; i < targetLights.Length; i++)
        {
            if (targetLights[i] != null)
            {
                originalIntensities[i] = targetLights[i].intensity;
                originalColors[i] = targetLights[i].color; // 保存原始颜色
                
                // 为每个光源生成随机参数
                lightRandomOffsets[i] = Random.Range(0f, 1f); // 随机偏移
                lightRandomSpeeds[i] = Random.Range(0.5f, 2f); // 随机速度倍数
                lightRandomPhases[i] = Random.Range(0f, Mathf.PI * 2f); // 随机相位
                lightIndividualFrequencies[i] = Random.Range(flashFrequency * 0.5f, flashFrequency * 1.5f); // 独立频率
                
                if (enableDebugLog)
                {
                    Debug.Log($"[Icarus] 光源 {i} 初始化 - 原始强度: {originalIntensities[i]}, 原始颜色: {originalColors[i]}, 随机偏移: {lightRandomOffsets[i]:F2}, 速度倍数: {lightRandomSpeeds[i]:F2}");
                }
            }
        }
        
        isInitialized = true;
        
        if (enableDebugLog)
        {
            Debug.Log($"[Icarus] 光源系统初始化完成 - 共 {targetLights.Length} 个光源");
        }
    }
    
    /// <summary>
    /// 点击交互（VRChat自动调用）
    /// </summary>
    public override void Interact()
    {
        if (!enableClickInteraction)
        {
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 点击交互已禁用");
            }
            return;
        }
        
        // 检查是否已经使用过（单次使用模式）
        if (singleUseOnly && hasBeenUsed)
        {
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 开关已使用过，无法再次触发");
            }
            return;
        }
        
        // 检查冷却时间
        if (Time.time - lastClickTime < clickCooldown)
        {
            if (enableDebugLog)
            {
                Debug.Log($"[Icarus] 点击冷却中，剩余时间: {clickCooldown - (Time.time - lastClickTime):F1}秒");
            }
            return;
        }
        
        // 检查是否正在闪烁
        if (isFlashing)
        {
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 光源正在闪烁中，忽略点击");
            }
            return;
        }
        
        // 开始闪烁
        StartFlash();
        lastClickTime = Time.time;
        
        // 标记为已使用（如果是单次使用模式）
        if (singleUseOnly)
        {
            hasBeenUsed = true;
        }
        
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 点击触发光源闪烁");
        }
    }
    
    /// <summary>
    /// 开始闪烁动画
    /// </summary>
    public void StartFlash()
    {
        if (!isInitialized || targetLights == null)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 光源系统未初始化，无法开始闪烁");
            }
            return;
        }
        
        // 重新检查并修复数组长度问题
        if (lightFlashingStates == null || lightFlashingStates.Length != targetLights.Length)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 检测到数组长度不匹配，重新初始化光源系统");
            }
            InitializeLightSystem();
        }
        
        isFlashing = true;
        flashStartTime = Time.time;
        currentFlashDuration = Random.Range(flashDurationMin, flashDurationMax);
        
        // 开始播放音频
        StartAudio();
        
        // 为每个光源设置独立的闪烁状态
        int activeLightCount = 0;
        for (int i = 0; i < targetLights.Length; i++)
        {
            // 检查数组边界
            if (i >= lightFlashingStates.Length || i >= lightFlashStartTimes.Length || 
                i >= lightFlashDurations.Length || i >= lightRandomOffsets.Length || 
                i >= lightRandomSpeeds.Length || i >= lightRandomPhases.Length || 
                i >= lightIndividualFrequencies.Length)
            {
                if (enableDebugLog)
                {
                    int arrayLength = lightFlashingStates != null ? lightFlashingStates.Length : 0;
                    Debug.LogError($"[Icarus] 数组越界错误！索引 {i} 超出范围，数组长度: {arrayLength}");
                }
                continue;
            }
            
            if (targetLights[i] != null)
            {
                // 设置独立闪烁状态
                lightFlashingStates[i] = true;
                lightFlashStartTimes[i] = Time.time + Random.Range(0f, 0.5f); // 随机延迟启动
                lightFlashDurations[i] = Random.Range(flashDurationMin, flashDurationMax); // 独立持续时间
                
                // 重新生成随机参数
                lightRandomOffsets[i] = Random.Range(0f, 1f);
                lightRandomSpeeds[i] = Random.Range(0.5f, 2f);
                lightRandomPhases[i] = Random.Range(0f, Mathf.PI * 2f);
                lightIndividualFrequencies[i] = Random.Range(flashFrequency * 0.5f, flashFrequency * 1.5f);
                
                activeLightCount++;
                
                if (enableDebugLog)
                {
                    Debug.Log($"[Icarus] 光源 {i} 独立闪烁设置 - 延迟: {lightFlashStartTimes[i] - Time.time:F2}秒, 持续时间: {lightFlashDurations[i]:F2}秒, 频率: {lightIndividualFrequencies[i]:F1}");
                }
            }
            else
            {
                // 确保null光源的状态被正确设置
                lightFlashingStates[i] = false;
                if (enableDebugLog)
                {
                    Debug.LogWarning($"[Icarus] 光源 {i} 为null，跳过闪烁设置");
                }
            }
        }
        
        if (enableDebugLog)
        {
            Debug.Log($"[Icarus] 开始独立闪烁动画 - 总体持续时间: {currentFlashDuration:F2}秒, 强度倍数: {intensityMultiplier}, 随机强度: {randomnessIntensity}, 活跃光源数量: {activeLightCount}/{targetLights.Length}");
        }
    }
    
    /// <summary>
    /// 更新闪烁动画
    /// </summary>
    void UpdateFlashAnimation()
    {
        bool anyLightStillFlashing = false;
        
        // 检查数组是否有效
        if (lightFlashingStates == null || lightFlashStartTimes == null || lightFlashDurations == null)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] 闪烁状态数组未初始化，无法更新闪烁动画");
            }
            return;
        }
        
        // 为每个光源独立更新闪烁状态
        for (int i = 0; i < targetLights.Length; i++)
        {
            // 检查数组边界
            if (i >= lightFlashingStates.Length || i >= lightFlashStartTimes.Length || 
                i >= lightFlashDurations.Length || i >= originalIntensities.Length)
            {
                if (enableDebugLog && Time.time % 5f < 0.1f)
                {
                    Debug.LogError($"[Icarus] 更新闪烁时数组越界！索引 {i} 超出范围");
                }
                continue;
            }
            
            if (targetLights[i] != null && lightFlashingStates[i])
            {
                // 检查该光源是否应该开始闪烁
                if (Time.time >= lightFlashStartTimes[i])
                {
                    // 计算该光源的独立闪烁进度
                    float lightElapsedTime = Time.time - lightFlashStartTimes[i];
                    float lightProgress = lightElapsedTime / lightFlashDurations[i];
                    
                    if (lightProgress >= 1f)
                    {
                        // 该光源闪烁结束
                        lightFlashingStates[i] = false;
                        targetLights[i].intensity = originalIntensities[i];
                        
                        if (enableDebugLog && Time.time % 2f < 0.1f)
                        {
                            Debug.Log($"[Icarus] 光源 {i} 闪烁结束");
                        }
                    }
                    else
                    {
                        // 该光源仍在闪烁
                        anyLightStillFlashing = true;
                        
                        // 计算该光源的随机闪烁强度
                        float flashIntensity = CalculateRandomFlashIntensity(lightProgress, i);
                        float targetIntensity = originalIntensities[i] * flashIntensity;
                        targetLights[i].intensity = targetIntensity;
                    }
                }
                else
                {
                    // 该光源还未开始闪烁，但标记为闪烁状态
                    anyLightStillFlashing = true;
                }
            }
        }
        
        // 检查总体闪烁是否结束
        if (!anyLightStillFlashing)
        {
            EndFlash();
        }
    }
    
    /// <summary>
    /// 计算单个光源的随机闪烁强度
    /// </summary>
    float CalculateRandomFlashIntensity(float progress, int lightIndex)
    {
        // 检查数组边界
        if (lightIndex < 0 || lightIndex >= lightRandomSpeeds.Length || 
            lightIndex >= lightRandomPhases.Length || lightIndex >= lightRandomOffsets.Length)
        {
            if (enableDebugLog && Time.time % 5f < 0.1f)
            {
                Debug.LogError($"[Icarus] 计算闪烁强度时数组越界！索引 {lightIndex} 超出范围");
            }
            return 1f; // 返回默认强度
        }
        
        // 基础闪烁强度
        float baseIntensity = CalculateBaseFlashIntensity(progress, lightIndex);
        
        // 应用随机变化
        float randomFactor = 1f;
        
        if (randomnessIntensity > 0f)
        {
            // 时间基础随机
            float timeRandom = Mathf.PerlinNoise(Time.time * lightRandomSpeeds[lightIndex] + lightRandomPhases[lightIndex], 0f);
            
            // 进度基础随机
            float progressRandom = Mathf.PerlinNoise(progress * 10f + lightRandomOffsets[lightIndex], 0f);
            
            // 组合随机因子
            randomFactor = Mathf.Lerp(1f, timeRandom * progressRandom, randomnessIntensity);
            
            // 添加额外的随机噪声
            float noiseRandom = Random.Range(0.8f, 1.2f);
            randomFactor *= Mathf.Lerp(1f, noiseRandom, randomnessIntensity * 0.5f);
        }
        
        // 应用随机因子到基础强度
        float finalIntensity = baseIntensity * randomFactor;
        
        // 确保在合理范围内
        finalIntensity = Mathf.Clamp(finalIntensity, 0.05f, intensityMultiplier);
        
        return finalIntensity;
    }
    
    /// <summary>
    /// 计算基础闪烁强度
    /// </summary>
    float CalculateBaseFlashIntensity(float progress, int lightIndex)
    {
        // 检查数组边界
        if (lightIndex < 0 || lightIndex >= lightIndividualFrequencies.Length)
        {
            if (enableDebugLog && Time.time % 5f < 0.1f)
            {
                Debug.LogError($"[Icarus] 计算基础闪烁强度时数组越界！索引 {lightIndex} 超出范围");
            }
            return 1f; // 返回默认强度
        }
        
        float intensity = 1f;
        
        switch (flashCurveType)
        {
            case FlashCurveType.Smooth:
                // 平滑闪烁：使用正弦波，但频率更高
                intensity = 1f + (intensityMultiplier - 1f) * Mathf.Sin(progress * Mathf.PI * lightIndividualFrequencies[lightIndex]);
                break;
                
            case FlashCurveType.Sharp:
                // 尖锐闪烁：快速上升，快速下降，强烈的明暗对比
                float sharpProgress = (progress * lightIndividualFrequencies[lightIndex]) % 1f;
                if (sharpProgress < 0.1f)
                {
                    // 快速上升
                    intensity = 1f + (intensityMultiplier - 1f) * (sharpProgress / 0.1f);
                }
                else if (sharpProgress < 0.2f)
                {
                    // 保持高亮度
                    intensity = intensityMultiplier;
                }
                else
                {
                    // 快速下降
                    intensity = 1f + (intensityMultiplier - 1f) * (1f - (sharpProgress - 0.2f) / 0.8f);
                }
                break;
                
            case FlashCurveType.Pulse:
                // 脉冲闪烁：多次强烈闪烁
                float pulseProgress = progress * lightIndividualFrequencies[lightIndex] * 2f; // 更频繁的脉冲
                intensity = 1f + (intensityMultiplier - 1f) * Mathf.Sin(pulseProgress * Mathf.PI) * Mathf.Exp(-progress * 1.5f);
                break;
                
            case FlashCurveType.Wave:
                // 波浪闪烁：快速波浪形变化
                intensity = 1f + (intensityMultiplier - 1f) * Mathf.Sin(progress * Mathf.PI * lightIndividualFrequencies[lightIndex] * 2f) * (1f - progress * 0.5f);
                break;
        }
        
        // 确保强烈的明暗对比
        if (intensity < 0.1f)
        {
            intensity = 0.1f; // 最小亮度
        }
        else if (intensity > intensityMultiplier)
        {
            intensity = intensityMultiplier; // 最大亮度
        }
        
        return intensity;
    }
    
    /// <summary>
    /// 开始播放音频
    /// </summary>
    void StartAudio()
    {
        if (!enableAudio || flashAudioSource == null)
        {
            if (enableDebugLog && enableAudio)
            {
                Debug.LogWarning("[Icarus] 音频源未分配，音频播放已禁用");
            }
            return;
        }
        
        // 保存原始音量
        if (!audioInitialized)
        {
            originalAudioVolume = flashAudioSource.volume;
            audioInitialized = true;
        }
        
        // 强制设置音源为3D音效
        flashAudioSource.volume = 0f; // 从静音开始，用于淡入
        flashAudioSource.loop = loopAudio;
        flashAudioSource.maxDistance = audioMaxDistance; // 设置最大听音范围
        flashAudioSource.spatialBlend = 1f; // 设置为3D音效（1.0 = 完全3D）
        flashAudioSource.rolloffMode = AudioRolloffMode.Linear; // 线性衰减
        flashAudioSource.minDistance = 1f; // 最小距离
        flashAudioSource.dopplerLevel = 0f; // 禁用多普勒效应
        flashAudioSource.playOnAwake = false; // 不自动播放
        flashAudioSource.mute = false; // 确保不是静音状态
        
        // 音频从音源位置播放，不需要修改位置
        // flashAudioSource.transform.position 保持音源原始位置
        
        // 开始播放
        flashAudioSource.Play();
        isAudioPlaying = true;
        audioStartTime = Time.time;
        isAudioFadingOut = false;
        
        if (enableDebugLog)
        {
            Debug.Log($"[Icarus] 开始播放音频 - 音量: {audioVolume}, 循环: {loopAudio}, 最大范围: {audioMaxDistance}m");
            Debug.Log($"[Icarus] 音频播放位置: {flashAudioSource.transform.position}");
            Debug.Log($"[Icarus] 音源设置 - 空间混合: {flashAudioSource.spatialBlend}, 衰减模式: {flashAudioSource.rolloffMode}");
        }
    }
    
    /// <summary>
    /// 停止播放音频
    /// </summary>
    void StopAudio()
    {
        if (!enableAudio || flashAudioSource == null || !isAudioPlaying)
        {
            return;
        }
        
        // 开始淡出
        isAudioFadingOut = true;
        audioFadeStartTime = Time.time;
        
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 开始音频淡出");
        }
    }
    
    /// <summary>
    /// 强制停止音频（立即停止，无淡出）
    /// </summary>
    void ForceStopAudio()
    {
        if (flashAudioSource != null)
        {
            // 无论是否在播放状态，都强制停止
            flashAudioSource.Stop();
            flashAudioSource.volume = originalAudioVolume;
            isAudioPlaying = false;
            isAudioFadingOut = false;
            
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 音频已强制停止");
            }
        }
    }
    
    /// <summary>
    /// 强制停止所有音频（可在Inspector中调用）
    /// </summary>
    [ContextMenu("强制停止所有音频")]
    public void ForceStopAllAudio()
    {
        if (flashAudioSource != null)
        {
            flashAudioSource.Stop();
            flashAudioSource.volume = originalAudioVolume;
            isAudioPlaying = false;
            isAudioFadingOut = false;
            
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 所有音频已强制停止");
            }
        }
        else
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 没有分配音频源");
            }
        }
    }
    
    /// <summary>
    /// 更新音频播放
    /// </summary>
    void UpdateAudio()
    {
        if (!enableAudio || flashAudioSource == null || !isAudioPlaying)
        {
            return;
        }
        
        float currentTime = Time.time;
        
        if (isAudioFadingOut)
        {
            // 音频淡出
            float fadeProgress = (currentTime - audioFadeStartTime) / audioFadeOutTime;
            
            if (fadeProgress >= 1f)
            {
                // 淡出完成，停止音频
                flashAudioSource.Stop();
                flashAudioSource.volume = originalAudioVolume;
                isAudioPlaying = false;
                isAudioFadingOut = false;
                
                if (enableDebugLog)
                {
                    Debug.Log("[Icarus] 音频播放结束");
                }
            }
            else
            {
                // 继续淡出
                float targetVolume = Mathf.Lerp(audioVolume, 0f, fadeProgress);
                flashAudioSource.volume = targetVolume;
            }
        }
        else
        {
            // 音频淡入
            float fadeProgress = (currentTime - audioStartTime) / audioFadeInTime;
            
            if (fadeProgress >= 1f)
            {
                // 淡入完成，设置目标音量
                flashAudioSource.volume = audioVolume;
            }
            else
            {
                // 继续淡入
                float targetVolume = Mathf.Lerp(0f, audioVolume, fadeProgress);
                flashAudioSource.volume = targetVolume;
            }
        }
    }
    
    /// <summary>
    /// 结束闪烁动画
    /// </summary>
    void EndFlash()
    {
        isFlashing = false;
        
        // 强制停止音频播放
        ForceStopAudio();
        
        // 确保所有光源都恢复到原始强度
        int restoredLightCount = 0;
        for (int i = 0; i < targetLights.Length; i++)
        {
            // 检查数组边界
            if (i >= originalIntensities.Length || i >= lightFlashingStates.Length)
            {
                if (enableDebugLog)
                {
                    Debug.LogError($"[Icarus] EndFlash时数组越界！索引 {i} 超出范围");
                }
                continue;
            }
            
            if (targetLights[i] != null)
            {
                targetLights[i].intensity = originalIntensities[i];
                lightFlashingStates[i] = false;
                restoredLightCount++;
            }
        }
        
        if (enableDebugLog)
        {
            Debug.Log($"[Icarus] 闪烁动画结束，已恢复 {restoredLightCount}/{targetLights.Length} 个光源的强度");
        }
        
        // 如果启用了等待和红色灯光功能，开始等待阶段
        if (enableWaitAndRedLight)
        {
            StartWaitForRedLight();
        }
    }
    
    /// <summary>
    /// 开始等待红色灯光阶段
    /// </summary>
    void StartWaitForRedLight()
    {
        isWaitingForRedLight = true;
        waitStartTime = Time.time;
        currentWaitDuration = Random.Range(waitTimeMin, waitTimeMax);
        
        // 重置贴图相关状态，确保每次新的等待周期都能正确启动贴图移动
        isTextureStarted = false;
        isTextureMoving = false;
        hasKilledPlayer = false;
        
        if (enableDebugLog)
        {
            Debug.Log($"[Icarus] 开始等待红色灯光阶段 - 等待时间: {currentWaitDuration:F1}秒");
        }
    }
    
    /// <summary>
    /// 更新等待和红色灯光状态
    /// </summary>
    void UpdateWaitAndRedLight()
    {
        if (isWaitingForRedLight)
        {
            float elapsedWaitTime = Time.time - waitStartTime;
            
            if (elapsedWaitTime >= currentWaitDuration)
            {
                // 等待时间结束，瞬间激活红色灯光
                ActivateRedLight();
                
                if (enableDebugLog)
                {
                    Debug.Log($"[Icarus] 等待时间结束！灯光瞬间变红，亮度翻倍！");
                }
            }
        }
        
        // 检查红色灯光持续时间
        if (isRedLightActive)
        {
            float elapsedRedLightTime = Time.time - redLightStartTime;
            
            // 在红灯时间结束前1秒启动贴图移动（只启动一次，使用精确时间控制）
            float textureStartTime = redLightDuration - 1f;
            if (elapsedRedLightTime >= textureStartTime && elapsedRedLightTime < textureStartTime + 0.1f && !isTextureStarted && !isTextureMoving && enableTextureMovement)
            {
                StartTextureMovement();
                isTextureStarted = true;
                
                if (enableDebugLog)
                {
                    Debug.Log($"[Icarus] 红灯时间结束前1秒，开始贴图移动！当前时间: {elapsedRedLightTime:F2}秒");
                }
            }
            
            if (elapsedRedLightTime >= redLightDuration)
            {
                // 红色灯光持续时间结束，自动重置
                AutoResetRedLight();
                
                if (enableDebugLog)
                {
                    Debug.Log($"[Icarus] 红色灯光持续时间结束！自动重置为原始状态！");
                }
            }
        }
    }
    
    /// <summary>
    /// 激活红色灯光
    /// </summary>
    void ActivateRedLight()
    {
        isWaitingForRedLight = false;
        isRedLightActive = true;
        redLightStartTime = Time.time; // 记录红色灯光开始时间
        
        // 注意：不重置isTextureStarted，保持从等待阶段继承的状态
        
        // 将所有光源瞬间设置为红色，亮度翻倍
        for (int i = 0; i < targetLights.Length; i++)
        {
            if (targetLights[i] != null && i < originalIntensities.Length)
            {
                targetLights[i].color = redLightColor;
                // 使用原始强度的倍数，实现亮度翻倍效果
                float newIntensity = originalIntensities[i] * redLightIntensityMultiplier;
                targetLights[i].intensity = newIntensity;
                
                if (enableDebugLog)
                {
                    Debug.Log($"[Icarus] 光源 {i} 变红 - 原始强度: {originalIntensities[i]:F2}, 新强度: {newIntensity:F2}, 倍数: {redLightIntensityMultiplier}");
                }
            }
        }
        
        // 开始播放红色灯光音效
        StartRedLightAudio();
        
        if (enableDebugLog)
        {
            Debug.Log($"[Icarus] 红色灯光已瞬间激活 - 颜色: {redLightColor}, 强度倍数: {redLightIntensityMultiplier}, 持续时间: {redLightDuration}秒");
        }
    }
    
    /// <summary>
    /// 重置红色灯光（恢复到原始状态）
    /// </summary>
    public void ResetRedLight()
    {
        isRedLightActive = false;
        
        // 停止红色灯光音效
        ForceStopRedLightAudio();
        
        // 恢复所有光源的原始颜色和强度
        for (int i = 0; i < targetLights.Length; i++)
        {
            if (targetLights[i] != null && i < originalColors.Length && i < originalIntensities.Length)
            {
                targetLights[i].color = originalColors[i];
                targetLights[i].intensity = originalIntensities[i];
            }
        }
        
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 红色灯光已手动重置，恢复到原始状态");
        }
    }
    
    /// <summary>
    /// 自动重置红色灯光（时间到期后自动调用）
    /// </summary>
    void AutoResetRedLight()
    {
        isRedLightActive = false;
        
        // 停止红色灯光音效
        ForceStopRedLightAudio();
        
        // 恢复所有光源的原始颜色和强度
        for (int i = 0; i < targetLights.Length; i++)
        {
            if (targetLights[i] != null && i < originalColors.Length && i < originalIntensities.Length)
            {
                targetLights[i].color = originalColors[i];
                targetLights[i].intensity = originalIntensities[i];
            }
        }
        
        // 注意：不重置isTextureStarted，确保贴图移动只启动一次
        
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 红色灯光已自动重置，恢复到原始状态");
        }
    }
    
    /// <summary>
    /// 开始播放红色灯光音频
    /// </summary>
    void StartRedLightAudio()
    {
        if (!enableAudio || redLightAudioSource == null)
        {
            if (enableDebugLog && enableAudio)
            {
                Debug.LogWarning("[Icarus] 红色灯光音频源未分配，音频播放已禁用");
            }
            return;
        }
        
        // 保存原始音量
        if (!redLightAudioInitialized)
        {
            originalRedLightAudioVolume = redLightAudioSource.volume;
            redLightAudioInitialized = true;
        }
        
        // 使用与闪烁音源相同的设置，但红色灯光音效不循环
        redLightAudioSource.volume = 0f; // 从静音开始，用于淡入
        redLightAudioSource.loop = false; // 红色灯光音效只播放一次，不循环
        redLightAudioSource.maxDistance = audioMaxDistance;
        redLightAudioSource.spatialBlend = 1f; // 设置为3D音效
        redLightAudioSource.rolloffMode = AudioRolloffMode.Linear;
        redLightAudioSource.minDistance = 1f;
        redLightAudioSource.dopplerLevel = 0f;
        redLightAudioSource.playOnAwake = false;
        redLightAudioSource.mute = false;
        
        // 开始播放
        redLightAudioSource.Play();
        isRedLightAudioPlaying = true;
        redLightAudioStartTime = Time.time;
        isRedLightAudioFadingOut = false;
        
        if (enableDebugLog)
        {
            Debug.Log($"[Icarus] 开始播放红色灯光音频 - 音量: {audioVolume}, 循环: 否（只播放一次）, 最大范围: {audioMaxDistance}m");
        }
    }
    
    /// <summary>
    /// 停止播放红色灯光音频
    /// </summary>
    void StopRedLightAudio()
    {
        if (!enableAudio || redLightAudioSource == null || !isRedLightAudioPlaying)
        {
            return;
        }
        
        // 开始淡出
        isRedLightAudioFadingOut = true;
        redLightAudioFadeStartTime = Time.time;
        
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 开始红色灯光音频淡出");
        }
    }
    
    /// <summary>
    /// 强制停止红色灯光音频（立即停止，无淡出）
    /// </summary>
    void ForceStopRedLightAudio()
    {
        if (redLightAudioSource != null)
        {
            // 无论是否在播放状态，都强制停止
            redLightAudioSource.Stop();
            redLightAudioSource.volume = originalRedLightAudioVolume;
            isRedLightAudioPlaying = false;
            isRedLightAudioFadingOut = false;
            
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 红色灯光音频已强制停止");
            }
        }
    }
    
    /// <summary>
    /// 更新红色灯光音频播放
    /// </summary>
    void UpdateRedLightAudio()
    {
        if (!enableAudio || redLightAudioSource == null || !isRedLightAudioPlaying)
        {
            return;
        }
        
        float currentTime = Time.time;
        
        if (isRedLightAudioFadingOut)
        {
            // 音频淡出
            float fadeProgress = (currentTime - redLightAudioFadeStartTime) / audioFadeOutTime;
            
            if (fadeProgress >= 1f)
            {
                // 淡出完成，停止音频
                redLightAudioSource.Stop();
                redLightAudioSource.volume = originalRedLightAudioVolume;
                isRedLightAudioPlaying = false;
                isRedLightAudioFadingOut = false;
                
                if (enableDebugLog)
                {
                    Debug.Log("[Icarus] 红色灯光音频播放结束");
                }
            }
            else
            {
                // 继续淡出
                float targetVolume = Mathf.Lerp(audioVolume, 0f, fadeProgress);
                redLightAudioSource.volume = targetVolume;
            }
        }
        else
        {
            // 检查音频是否播放完毕（非循环音频）
            if (!redLightAudioSource.isPlaying && !isRedLightAudioFadingOut)
            {
                // 音频播放完毕，停止状态管理
                isRedLightAudioPlaying = false;
                redLightAudioSource.volume = originalRedLightAudioVolume;
                
                if (enableDebugLog)
                {
                    Debug.Log("[Icarus] 红色灯光音频播放完毕（非循环）");
                }
                return;
            }
            
            // 音频淡入
            float fadeProgress = (currentTime - redLightAudioStartTime) / audioFadeInTime;
            
            if (fadeProgress >= 1f)
            {
                // 淡入完成，设置目标音量
                redLightAudioSource.volume = audioVolume;
            }
            else
            {
                // 继续淡入
                float targetVolume = Mathf.Lerp(0f, audioVolume, fadeProgress);
                redLightAudioSource.volume = targetVolume;
            }
        }
    }
    
    /// <summary>
    /// 检查和修复红色灯光音源设置
    /// </summary>
    void CheckAndFixRedLightAudioSource()
    {
        if (redLightAudioSource == null)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] 红色灯光音频源未分配，无法检查和修复");
            }
            return;
        }
        
        if (enableDebugLog)
        {
            Debug.Log("=== 红色灯光音源设置检查和修复 ===");
        }
        
        bool needsFix = false;
        
        // 检查并修复空间混合设置
        if (redLightAudioSource.spatialBlend != 1f)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 红色灯光音源空间混合设置错误: {redLightAudioSource.spatialBlend} (应为1.0)");
            }
            redLightAudioSource.spatialBlend = 1f;
            needsFix = true;
        }
        
        // 检查并修复衰减模式
        if (redLightAudioSource.rolloffMode != AudioRolloffMode.Linear)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 红色灯光音源衰减模式设置错误: {redLightAudioSource.rolloffMode} (应为Linear)");
            }
            redLightAudioSource.rolloffMode = AudioRolloffMode.Linear;
            needsFix = true;
        }
        
        // 检查并修复最大距离
        if (redLightAudioSource.maxDistance != audioMaxDistance)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 红色灯光音源最大距离设置错误: {redLightAudioSource.maxDistance} (应为{audioMaxDistance})");
            }
            redLightAudioSource.maxDistance = audioMaxDistance;
            needsFix = true;
        }
        
        // 检查并修复最小距离
        if (redLightAudioSource.minDistance != 1f)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 红色灯光音源最小距离设置错误: {redLightAudioSource.minDistance} (应为1.0)");
            }
            redLightAudioSource.minDistance = 1f;
            needsFix = true;
        }
        
        // 检查并修复自动播放设置
        if (redLightAudioSource.playOnAwake)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 红色灯光音源自动播放已启用，这可能导致音频在未触发时播放");
            }
            redLightAudioSource.playOnAwake = false;
            needsFix = true;
        }
        
        // 检查并修复静音设置
        if (redLightAudioSource.mute)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 红色灯光音源处于静音状态，这可能导致音频无法播放");
            }
            redLightAudioSource.mute = false;
            needsFix = true;
        }
        
        // 检查并修复音量设置
        if (redLightAudioSource.volume <= 0f)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 红色灯光音源音量过低: {redLightAudioSource.volume}，这可能导致音频无法听到");
            }
            redLightAudioSource.volume = originalRedLightAudioVolume > 0f ? originalRedLightAudioVolume : 0.5f;
            needsFix = true;
        }
        
        // 检查并修复多普勒效应
        if (redLightAudioSource.dopplerLevel != 0f)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 红色灯光音源多普勒效应已启用: {redLightAudioSource.dopplerLevel} (建议为0)");
            }
            redLightAudioSource.dopplerLevel = 0f;
            needsFix = true;
        }
        
        if (enableDebugLog)
        {
            if (needsFix)
            {
                Debug.Log("[Icarus] 红色灯光音源设置已修复");
            }
            else
            {
                Debug.Log("[Icarus] 红色灯光音源设置正确，无需修复");
            }
        }
    }
    
    /// <summary>
    /// 重置开关状态（可在Inspector中调用）
    /// </summary>
    [ContextMenu("重置开关状态")]
    public void ResetSwitch()
    {
        hasBeenUsed = false;
        isFlashing = false;
        isWaitingForRedLight = false;
        isRedLightActive = false;
        redLightStartTime = 0f;
        
        // 重置贴图相关状态
        isTextureMoving = false;
        isTextureStarted = false;
        currentPathIndex = 0;
        hasKilledPlayer = false;
        
        // 隐藏贴图
        if (movingTexture != null)
        {
            movingTexture.SetActive(false);
        }
        
        // 强制停止音频
        ForceStopAudio();
        ForceStopRedLightAudio();
        
        // 恢复所有光源原始强度和颜色
        if (targetLights != null)
        {
            for (int i = 0; i < targetLights.Length; i++)
            {
                if (targetLights[i] != null && i < originalIntensities.Length && i < originalColors.Length)
                {
                    targetLights[i].intensity = originalIntensities[i];
                    targetLights[i].color = originalColors[i];
                }
            }
        }
        
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 开关状态已重置，包括红色灯光状态和贴图状态");
        }
    }
    
    /// <summary>
    /// 测试闪烁效果（可在Inspector中调用）
    /// </summary>
    [ContextMenu("测试闪烁效果")]
    public void TestFlash()
    {
        if (!isFlashing)
        {
            StartFlash();
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 测试闪烁效果");
            }
        }
        else
        {
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 闪烁正在进行中，无法测试");
            }
        }
    }
    
    /// <summary>
    /// 测试音频效果（可在Inspector中调用）
    /// </summary>
    [ContextMenu("测试音频效果")]
    public void TestAudio()
    {
        if (!enableAudio)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 音频功能已禁用");
            }
            return;
        }
        
        if (flashAudioSource == null)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] 音频源未分配，无法测试音频");
            }
            return;
        }
        
        if (!isAudioPlaying)
        {
            StartAudio();
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 测试音频效果");
            }
        }
        else
        {
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 音频正在播放中，无法测试");
            }
        }
    }
    
    /// <summary>
    /// 测试等待和红色灯光功能（可在Inspector中调用）
    /// </summary>
    [ContextMenu("测试等待和红色灯光功能")]
    public void TestWaitAndRedLight()
    {
        if (!enableWaitAndRedLight)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 等待和红色灯光功能已禁用");
            }
            return;
        }
        
        if (isWaitingForRedLight || isRedLightActive)
        {
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 等待或红色灯光功能正在进行中，无法测试");
            }
            return;
        }
        
        StartWaitForRedLight();
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 开始测试等待和红色灯光功能");
        }
    }
    
    /// <summary>
    /// 立即激活红色灯光（可在Inspector中调用）
    /// </summary>
    [ContextMenu("立即激活红色灯光")]
    public void ActivateRedLightImmediately()
    {
        if (!enableWaitAndRedLight)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 等待和红色灯光功能已禁用");
            }
            return;
        }
        
        isWaitingForRedLight = false;
        ActivateRedLight();
        
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 红色灯光已立即激活，亮度翻倍！");
        }
    }
    
    /// <summary>
    /// 测试红色灯光音频（可在Inspector中调用）
    /// </summary>
    [ContextMenu("测试红色灯光音频")]
    public void TestRedLightAudio()
    {
        if (!enableAudio)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 音频功能已禁用");
            }
            return;
        }
        
        if (redLightAudioSource == null)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] 红色灯光音频源未分配，无法测试");
            }
            return;
        }
        
        if (!isRedLightAudioPlaying)
        {
            StartRedLightAudio();
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 测试红色灯光音频效果");
            }
        }
        else
        {
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 红色灯光音频正在播放中，无法测试");
            }
        }
    }
    
    /// <summary>
    /// 测试红色灯光自动重置（可在Inspector中调用）
    /// </summary>
    [ContextMenu("测试红色灯光自动重置")]
    public void TestRedLightAutoReset()
    {
        if (!enableWaitAndRedLight)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 等待和红色灯光功能已禁用");
            }
            return;
        }
        
        if (isRedLightActive)
        {
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 红色灯光已激活，将测试自动重置功能");
            }
        }
        else
        {
            // 先激活红色灯光
            ActivateRedLight();
            if (enableDebugLog)
            {
                Debug.Log("[Icarus] 已激活红色灯光，开始测试自动重置功能");
            }
        }
    }
    
    /// <summary>
    /// 测试瞬间变红效果（可在Inspector中调用）
    /// </summary>
    [ContextMenu("测试瞬间变红效果")]
    public void TestInstantRedLight()
    {
        if (!enableWaitAndRedLight)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 等待和红色灯光功能已禁用");
            }
            return;
        }
        
        if (targetLights == null || targetLights.Length == 0)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] 没有分配光源，无法测试");
            }
            return;
        }
        
        // 先恢复到原始状态
        for (int i = 0; i < targetLights.Length; i++)
        {
            if (targetLights[i] != null && i < originalIntensities.Length && i < originalColors.Length)
            {
                targetLights[i].color = originalColors[i];
                targetLights[i].intensity = originalIntensities[i];
            }
        }
        
        // 直接瞬间变红
        ActivateRedLight();
        
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 瞬间变红效果测试完成！");
        }
    }
    
    /// <summary>
    /// 测试音源范围（可在Inspector中调用）
    /// </summary>
    [ContextMenu("测试音源范围")]
    public void TestAudioRange()
    {
        if (flashAudioSource == null)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] 音频源未分配，无法测试音源范围");
            }
            return;
        }
        
        if (enableDebugLog)
        {
            Debug.Log("=== 音源范围测试 ===");
            Debug.Log($"音源位置: {flashAudioSource.transform.position}");
            Debug.Log($"开关位置: {transform.position}");
            Debug.Log($"开关到音源距离: {Vector3.Distance(transform.position, flashAudioSource.transform.position):F2}米");
            Debug.Log($"音源最大范围: {audioMaxDistance}米");
            Debug.Log($"音源当前音量: {flashAudioSource.volume}");
            Debug.Log($"音源空间混合: {flashAudioSource.spatialBlend}");
            
            // 计算与玩家的距离（以音源位置为准）
            if (Networking.LocalPlayer != null)
            {
                Vector3 playerPosition = Networking.LocalPlayer.GetPosition();
                Vector3 audioPosition = flashAudioSource.transform.position;
                float distanceToPlayer = Vector3.Distance(audioPosition, playerPosition);
                Debug.Log($"玩家距离音源: {distanceToPlayer:F2}米");
                Debug.Log($"是否在听音范围内: {(distanceToPlayer <= audioMaxDistance ? "是" : "否")}");
            }
        }
    }
    
    /// <summary>
    /// 检查和修复音源设置（可在Inspector中调用）
    /// </summary>
    [ContextMenu("检查和修复音源设置")]
    public void CheckAndFixAudioSource()
    {
        if (flashAudioSource == null)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] 音频源未分配，无法检查和修复");
            }
            return;
        }
        
        if (enableDebugLog)
        {
            Debug.Log("=== 音源设置检查和修复 ===");
        }
        
        bool needsFix = false;
        
        // 检查并修复空间混合设置
        if (flashAudioSource.spatialBlend != 1f)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 音源空间混合设置错误: {flashAudioSource.spatialBlend} (应为1.0)");
            }
            flashAudioSource.spatialBlend = 1f;
            needsFix = true;
        }
        
        // 检查并修复衰减模式
        if (flashAudioSource.rolloffMode != AudioRolloffMode.Linear)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 音源衰减模式设置错误: {flashAudioSource.rolloffMode} (应为Linear)");
            }
            flashAudioSource.rolloffMode = AudioRolloffMode.Linear;
            needsFix = true;
        }
        
        // 检查并修复最大距离
        if (flashAudioSource.maxDistance != audioMaxDistance)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 音源最大距离设置错误: {flashAudioSource.maxDistance} (应为{audioMaxDistance})");
            }
            flashAudioSource.maxDistance = audioMaxDistance;
            needsFix = true;
        }
        
        // 检查并修复最小距离
        if (flashAudioSource.minDistance != 1f)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 音源最小距离设置错误: {flashAudioSource.minDistance} (应为1.0)");
            }
            flashAudioSource.minDistance = 1f;
            needsFix = true;
        }
        
        // 检查并修复自动播放设置
        if (flashAudioSource.playOnAwake)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 音源自动播放已启用，这可能导致音频在未触发时播放");
            }
            flashAudioSource.playOnAwake = false;
            needsFix = true;
        }
        
        // 检查并修复静音设置
        if (flashAudioSource.mute)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 音源处于静音状态，这可能导致音频无法播放");
            }
            flashAudioSource.mute = false;
            needsFix = true;
        }
        
        // 检查并修复音量设置
        if (flashAudioSource.volume <= 0f)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 音源音量过低: {flashAudioSource.volume}，这可能导致音频无法听到");
            }
            flashAudioSource.volume = originalAudioVolume > 0f ? originalAudioVolume : 0.5f;
            needsFix = true;
        }
        
        // 检查并修复多普勒效应
        if (flashAudioSource.dopplerLevel != 0f)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 音源多普勒效应已启用: {flashAudioSource.dopplerLevel} (建议为0)");
            }
            flashAudioSource.dopplerLevel = 0f;
            needsFix = true;
        }
        
        // 显示当前设置
        if (enableDebugLog)
        {
            Debug.Log("=== 当前音源设置 ===");
            Debug.Log($"空间混合: {flashAudioSource.spatialBlend}");
            Debug.Log($"衰减模式: {flashAudioSource.rolloffMode}");
            Debug.Log($"最大距离: {flashAudioSource.maxDistance}");
            Debug.Log($"最小距离: {flashAudioSource.minDistance}");
            Debug.Log($"自动播放: {flashAudioSource.playOnAwake}");
            Debug.Log($"多普勒效应: {flashAudioSource.dopplerLevel}");
            Debug.Log($"当前音量: {flashAudioSource.volume}");
            Debug.Log($"是否正在播放: {flashAudioSource.isPlaying}");
            
            if (needsFix)
            {
                Debug.Log("[Icarus] 音源设置已修复，现在应该正确支持范围控制");
            }
            else
            {
                Debug.Log("[Icarus] 音源设置正确，无需修复");
            }
        }
    }
    
    /// <summary>
    /// 显示当前状态（可在Inspector中调用）
    /// </summary>
    [ContextMenu("显示当前状态")]
    public void ShowCurrentStatus()
    {
        if (enableDebugLog)
        {
            Debug.Log("=== Icarus开关状态 ===");
            Debug.Log($"初始化状态: {(isInitialized ? "已初始化" : "未初始化")}");
            Debug.Log($"总体闪烁状态: {(isFlashing ? "闪烁中" : "空闲")}");
            Debug.Log($"等待红色灯光: {(isWaitingForRedLight ? "等待中" : "否")}");
            Debug.Log($"红色灯光激活: {(isRedLightActive ? "是" : "否")}");
            Debug.Log($"使用状态: {(hasBeenUsed ? "已使用" : "未使用")}");
            Debug.Log($"单次使用: {(singleUseOnly ? "是" : "否")}");
            Debug.Log($"光源数量: {(targetLights != null ? targetLights.Length : 0)}");
            Debug.Log($"点击交互: {(enableClickInteraction ? "启用" : "禁用")}");
            Debug.Log($"点击冷却: {clickCooldown}秒");
            Debug.Log($"闪烁持续时间范围: {flashDurationMin}-{flashDurationMax}秒");
            Debug.Log($"当前总体持续时间: {currentFlashDuration:F2}秒");
            Debug.Log($"强度倍数: {intensityMultiplier}");
            Debug.Log($"基础闪烁频率: {flashFrequency}次/秒");
            Debug.Log($"随机变化强度: {randomnessIntensity}");
            Debug.Log($"闪烁曲线: {flashCurveType}");
            
            // 等待和红色灯光设置信息
            Debug.Log("=== 等待和红色灯光设置 ===");
            Debug.Log($"等待和红色灯光功能: {(enableWaitAndRedLight ? "启用" : "禁用")}");
            Debug.Log($"等待时间范围: {waitTimeMin}-{waitTimeMax}秒");
            Debug.Log($"红色灯光强度倍数: {redLightIntensityMultiplier}");
            Debug.Log($"红色灯光颜色: {redLightColor}");
            Debug.Log($"红色灯光持续时间: {redLightDuration}秒");
            
            if (isWaitingForRedLight)
            {
                float elapsedWaitTime = Time.time - waitStartTime;
                float remainingWaitTime = currentWaitDuration - elapsedWaitTime;
                Debug.Log($"当前等待进度: {elapsedWaitTime:F1}/{currentWaitDuration:F1}秒 (剩余: {remainingWaitTime:F1}秒)");
            }
            
            if (isRedLightActive)
            {
                float elapsedRedLightTime = Time.time - redLightStartTime;
                float remainingRedLightTime = redLightDuration - elapsedRedLightTime;
                Debug.Log($"红色灯光进度: {elapsedRedLightTime:F1}/{redLightDuration:F1}秒 (剩余: {remainingRedLightTime:F1}秒)");
            }
            
            // 音频状态信息
            Debug.Log("=== 音频状态 ===");
            Debug.Log($"音频启用: {(enableAudio ? "是" : "否")}");
            Debug.Log($"闪烁音频源分配: {(flashAudioSource != null ? "是" : "否")}");
            Debug.Log($"闪烁音频播放状态: {(isAudioPlaying ? "播放中" : "停止")}");
            Debug.Log($"红色灯光音频源分配: {(redLightAudioSource != null ? "是" : "否")}");
            Debug.Log($"红色灯光音频播放状态: {(isRedLightAudioPlaying ? "播放中" : "停止")}");
            Debug.Log($"音频音量: {audioVolume}");
            Debug.Log($"音频循环: {(loopAudio ? "是" : "否")}");
            Debug.Log($"音频淡入时间: {audioFadeInTime}秒");
            Debug.Log($"音频淡出时间: {audioFadeOutTime}秒");
            Debug.Log($"音源最大范围: {audioMaxDistance}米");
            Debug.Log($"音源范围可视化: {(showAudioRange ? "启用" : "禁用")}");
            
            if (flashAudioSource != null)
            {
                Debug.Log($"音源位置: {flashAudioSource.transform.position}");
                Debug.Log($"音源当前音量: {flashAudioSource.volume}");
                Debug.Log($"音源最大距离: {flashAudioSource.maxDistance}");
                Debug.Log($"音源空间混合: {flashAudioSource.spatialBlend}");
            }
            
            // 显示每个光源的独立状态
            if (targetLights != null && lightFlashingStates != null)
            {
                Debug.Log("=== 光源独立状态 ===");
                for (int i = 0; i < targetLights.Length; i++)
                {
                    if (targetLights[i] != null && i < lightFlashingStates.Length)
                    {
                        string flashingStatus = lightFlashingStates[i] ? "闪烁中" : "空闲";
                        string startTimeInfo = "";
                        
                        if (lightFlashingStates[i] && i < lightFlashStartTimes.Length)
                        {
                            if (Time.time < lightFlashStartTimes[i])
                            {
                                startTimeInfo = $" (延迟启动: {lightFlashStartTimes[i] - Time.time:F2}秒)";
                            }
                            else if (i < lightFlashDurations.Length)
                            {
                                float elapsed = Time.time - lightFlashStartTimes[i];
                                float progress = elapsed / lightFlashDurations[i];
                                startTimeInfo = $" (进度: {progress:P0})";
                            }
                        }
                        
                        Debug.Log($"光源 {i}: {flashingStatus}{startTimeInfo}");
                    }
                }
            }
            
            // 显示每个光源的随机参数
            if (targetLights != null && lightRandomOffsets != null)
            {
                Debug.Log("=== 光源随机参数 ===");
                for (int i = 0; i < targetLights.Length; i++)
                {
                    if (targetLights[i] != null && i < lightRandomOffsets.Length)
                    {
                        string frequencyInfo = i < lightIndividualFrequencies.Length ? $", 频率={lightIndividualFrequencies[i]:F1}" : "";
                        string durationInfo = i < lightFlashDurations.Length ? $", 持续时间={lightFlashDurations[i]:F2}s" : "";
                        
                        Debug.Log($"光源 {i}: 偏移={lightRandomOffsets[i]:F2}, 速度={lightRandomSpeeds[i]:F2}, 相位={lightRandomPhases[i]:F2}{frequencyInfo}{durationInfo}");
                    }
                }
            }
        }
    }
    

    
    /// <summary>
    /// 绘制音源范围可视化（始终显示）
    /// </summary>
    void OnDrawGizmos()
    {
        if (!showAudioRange || flashAudioSource == null)
        {
            return;
        }
        
        // 绘制音源范围（更淡的颜色，以音源位置为中心）
        Vector3 audioPosition = flashAudioSource.transform.position;
        Gizmos.color = new Color(0f, 1f, 1f, 0.1f); // 更淡的青色
        Gizmos.DrawWireSphere(audioPosition, audioMaxDistance);
    }
    
    /// <summary>
    /// 绘制贴图移动路径可视化
    /// </summary>
    void OnDrawGizmosSelected()
    {
        // 绘制音源范围可视化
        if (showAudioRange && flashAudioSource != null)
        {
            Vector3 audioPosition = flashAudioSource.transform.position;
            Gizmos.color = new Color(0f, 1f, 1f, 0.3f); // 青色半透明
            Gizmos.DrawWireSphere(audioPosition, audioMaxDistance);
            
            Gizmos.color = Color.cyan;
            Gizmos.DrawSphere(audioPosition, 0.2f);
            
            Gizmos.color = Color.green;
            Gizmos.DrawWireSphere(transform.position, 0.3f);
            
            Gizmos.color = Color.yellow;
            Gizmos.DrawLine(transform.position, audioPosition);
        }
        
        // 绘制贴图移动路径可视化
        if (enableTextureMovement && pathPoints != null && pathPoints.Length > 0)
        {
            Gizmos.color = new Color(1f, 0f, 0f, 0.5f); // 红色半透明
            
            // 绘制路径点
            for (int i = 0; i < pathPoints.Length; i++)
            {
                if (pathPoints[i] != null)
                {
                    Gizmos.DrawSphere(pathPoints[i].position, 0.2f);
                    
                    // 绘制路径线
                    if (i < pathPoints.Length - 1 && pathPoints[i + 1] != null)
                    {
                        Gizmos.DrawLine(pathPoints[i].position, pathPoints[i + 1].position);
                    }
                }
            }
            
            // 绘制碰撞检测范围
            if (movingTexture != null)
            {
                Gizmos.color = new Color(1f, 0f, 1f, 0.3f); // 紫色半透明
                Gizmos.DrawWireSphere(movingTexture.transform.position, textureCollisionRadius);
            }
        }
    }
    
    /// <summary>
    /// 开始贴图移动
    /// </summary>
    void StartTextureMovement()
    {
        if (!enableTextureMovement || movingTexture == null || pathPoints == null || pathPoints.Length == 0)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 贴图移动功能未启用或路径点未设置");
            }
            return;
        }
        
        // 防止重复启动贴图移动
        if (isTextureMoving)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 贴图移动已在进行中，忽略重复启动请求");
            }
            return;
        }
        
        // 初始化贴图移动
        isTextureMoving = true;
        currentPathIndex = 0;
        hasKilledPlayer = false; // 重置杀死玩家标记
        textureStartPosition = movingTexture.transform.position;
        
        // 确保贴图可见
        movingTexture.SetActive(true);
        
        // 移动到第一个路径点
        if (pathPoints.Length > 0 && pathPoints[0] != null)
        {
            movingTexture.transform.position = pathPoints[0].position;
        }
        
        if (enableDebugLog)
        {
            Debug.Log($"[Icarus] 开始贴图移动 - 路径点数量: {pathPoints.Length}, 移动速度: {textureMoveSpeed}m/s");
        }
    }
    

    
    /// <summary>
    /// 更新贴图移动
    /// </summary>
    void UpdateTextureMovement()
    {
        if (!isTextureMoving || movingTexture == null || pathPoints == null || pathPoints.Length == 0)
        {
            return;
        }
        
        // 检查是否到达终点
        if (currentPathIndex >= pathPoints.Length)
        {
            EndTextureMovement();
            return;
        }
        
        // 获取当前目标点
        Transform targetPoint = pathPoints[currentPathIndex];
        if (targetPoint == null)
        {
            currentPathIndex++;
            return;
        }
        
        // 移动贴图
        Vector3 currentPos = movingTexture.transform.position;
        Vector3 targetPos = targetPoint.position;
        Vector3 direction = (targetPos - currentPos).normalized;
        float distance = Vector3.Distance(currentPos, targetPos);
        
        // 检查是否到达当前路径点
        if (distance < 0.1f)
        {
            currentPathIndex++;
            if (enableDebugLog && showTextureDebugInfo)
            {
                Debug.Log($"[Icarus] 贴图到达路径点 {currentPathIndex - 1}/{pathPoints.Length}");
            }
        }
        else
        {
            // 移动贴图
            Vector3 newPosition = currentPos + direction * textureMoveSpeed * Time.deltaTime;
            movingTexture.transform.position = newPosition;
            
            // 检测玩家碰撞
            CheckPlayerCollision();
        }
    }
    
    /// <summary>
    /// 检测玩家碰撞
    /// </summary>
    void CheckPlayerCollision()
    {
        if (Networking.LocalPlayer == null || movingTexture == null)
        {
            return;
        }
        
        Vector3 playerPosition = Networking.LocalPlayer.GetPosition();
        Vector3 texturePosition = movingTexture.transform.position;
        float distance = Vector3.Distance(playerPosition, texturePosition);
        
        // 添加详细的调试信息
        if (enableDebugLog && showTextureDebugInfo && Time.time % 2f < 0.1f)
        {
            Debug.Log($"[Icarus] 碰撞检测 - 玩家位置: {playerPosition}, 贴图位置: {texturePosition}, 距离: {distance:F2}m, 碰撞范围: {textureCollisionRadius}m");
        }
        
        if (distance <= textureCollisionRadius && !hasKilledPlayer)
        {
            // 玩家被贴图击中，立即清零生命值
            if (enableDebugLog)
            {
                Debug.LogWarning($"[Icarus] 玩家被贴图击中！距离: {distance:F2}m, 碰撞范围: {textureCollisionRadius}m");
            }
            
            // 调用WorldHealth脚本立即清零生命值（并做一次健壮性校验）
            if (worldHealthReference != null)
            {
                worldHealthReference.InstantlyKillPlayer();
                // 兼容性校验：若未置零，则直接强制为0（避免外部改动导致方法无效）
                if (!worldHealthReference.IsPlayerDead())
                {
                    worldHealthReference.SetHealth(0);
                }
                hasKilledPlayer = true; // 标记已经杀死过玩家
                if (enableDebugLog)
                {
                    Debug.LogWarning("[Icarus] 已调用WorldHealth脚本立即清零玩家生命值！贴图将继续移动到终点");
                }
            }
            else
            {
                if (enableDebugLog)
                {
                    Debug.LogError("[Icarus] WorldHealth脚本引用未分配！请在Inspector中分配worldHealthReference");
                }
            }
            
            // 注意：不立即结束贴图移动，让它继续移动到终点
        }
    }
    
    /// <summary>
    /// 结束贴图移动
    /// </summary>
    void EndTextureMovement()
    {
        isTextureMoving = false;
        hasKilledPlayer = false; // 重置杀死玩家标记
        isTextureStarted = false; // 重置贴图开始标记
        currentPathIndex = 0; // 重置路径索引
        
        // 隐藏贴图
        if (movingTexture != null)
        {
            movingTexture.SetActive(false);
        }
        
        if (enableDebugLog)
        {
            Debug.Log($"[Icarus] 贴图移动结束，贴图已隐藏，所有状态已重置");
        }
    }
    
    /// <summary>
    /// 测试贴图移动功能（可在Inspector中调用）
    /// </summary>
    [ContextMenu("测试贴图移动功能")]
    public void TestTextureMovement()
    {
        if (!enableTextureMovement)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] 贴图移动功能未启用");
            }
            return;
        }
        
        if (movingTexture == null)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] 贴图对象未分配！请在Inspector中分配movingTexture");
            }
            return;
        }
        
        if (pathPoints == null || pathPoints.Length == 0)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] 路径点未设置！请在Inspector中设置pathPoints数组");
            }
            return;
        }
        
        if (worldHealthReference == null)
        {
            if (enableDebugLog)
            {
                Debug.LogWarning("[Icarus] WorldHealth脚本引用未分配！碰撞检测功能可能无法正常工作");
            }
        }
        
        StartTextureMovement();
        
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 贴图移动测试已开始");
        }
    }
    
    /// <summary>
    /// 强制停止贴图移动（可在Inspector中调用）
    /// </summary>
    [ContextMenu("强制停止贴图移动")]
    public void ForceStopTextureMovement()
    {
        EndTextureMovement();
        
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 贴图移动已强制停止");
        }
    }
    
    /// <summary>
    /// 重置贴图移动状态（可在Inspector中调用）
    /// </summary>
    [ContextMenu("重置贴图移动状态")]
    public void ResetTextureMovementState()
    {
        isTextureMoving = false;
        hasKilledPlayer = false;
        currentPathIndex = 0;
        
        if (enableDebugLog)
        {
            Debug.Log("[Icarus] 贴图移动状态已重置");
        }
    }
    
    /// <summary>
    /// 显示贴图移动状态（可在Inspector中调用）
    /// </summary>
    [ContextMenu("显示贴图移动状态")]
    public void ShowTextureMovementStatus()
    {
        if (enableDebugLog)
        {
            Debug.Log("=== 贴图移动状态 ===");
            Debug.Log($"贴图移动功能启用: {enableTextureMovement}");
            Debug.Log($"贴图对象分配: {(movingTexture != null ? "是" : "否")}");
            Debug.Log($"路径点数量: {(pathPoints != null ? pathPoints.Length : 0)}");
            Debug.Log($"当前移动状态: {(isTextureMoving ? "移动中" : "停止")}");
            Debug.Log($"贴图开始标记: {isTextureStarted}");
            Debug.Log($"当前路径点索引: {currentPathIndex}");
            Debug.Log($"移动速度: {textureMoveSpeed}m/s");
            Debug.Log($"碰撞检测范围: {textureCollisionRadius}m");
            Debug.Log($"WorldHealth引用分配: {(worldHealthReference != null ? "是" : "否")}");
            Debug.Log($"是否已杀死玩家: {hasKilledPlayer}");
            
            // 显示红色灯光状态
            Debug.Log($"红色灯光激活: {isRedLightActive}");
            if (isRedLightActive)
            {
                float elapsedRedLightTime = Time.time - redLightStartTime;
                float remainingTime = redLightDuration - elapsedRedLightTime;
                float textureStartTime = redLightDuration - 1f;
                Debug.Log($"红色灯光已运行: {elapsedRedLightTime:F1}秒");
                Debug.Log($"红色灯光剩余时间: {remainingTime:F1}秒");
                Debug.Log($"贴图启动时间点: {textureStartTime:F1}秒");
                Debug.Log($"是否到达贴图启动时间点: {(elapsedRedLightTime >= textureStartTime ? "是" : "否")}");
                Debug.Log($"是否在启动时间窗口内: {(elapsedRedLightTime >= textureStartTime && elapsedRedLightTime < textureStartTime + 0.1f ? "是" : "否")}");
            }
            
            // 显示等待状态
            Debug.Log($"等待红色灯光: {isWaitingForRedLight}");
            if (isWaitingForRedLight)
            {
                float elapsedWaitTime = Time.time - waitStartTime;
                float remainingWaitTime = currentWaitDuration - elapsedWaitTime;
                Debug.Log($"等待已运行: {elapsedWaitTime:F1}秒");
                Debug.Log($"等待剩余时间: {remainingWaitTime:F1}秒");
            }

            
            if (pathPoints != null)
            {
                for (int i = 0; i < pathPoints.Length; i++)
                {
                    string status = pathPoints[i] != null ? "有效" : "无效";
                    string position = pathPoints[i] != null ? pathPoints[i].position.ToString() : "null";
                    Debug.Log($"路径点 {i}: {status} - 位置: {position}");
                }
            }
            
            // 显示当前玩家和贴图位置
            if (Networking.LocalPlayer != null && movingTexture != null)
            {
                Vector3 playerPos = Networking.LocalPlayer.GetPosition();
                Vector3 texturePos = movingTexture.transform.position;
                float distance = Vector3.Distance(playerPos, texturePos);
                Debug.Log($"当前玩家位置: {playerPos}");
                Debug.Log($"当前贴图位置: {texturePos}");
                Debug.Log($"当前距离: {distance:F2}m");
                Debug.Log($"是否在碰撞范围内: {(distance <= textureCollisionRadius ? "是" : "否")}");
            }
        }
    }
    
    /// <summary>
    /// 测试碰撞检测功能（可在Inspector中调用）
    /// </summary>
    [ContextMenu("测试碰撞检测功能")]
    public void TestCollisionDetection()
    {
        if (enableDebugLog)
        {
            Debug.Log("=== 开始测试碰撞检测功能 ===");
        }
        
        if (Networking.LocalPlayer == null)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] 本地玩家为空，无法测试碰撞检测");
            }
            return;
        }
        
        if (movingTexture == null)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] 贴图对象为空，无法测试碰撞检测");
            }
            return;
        }
        
        if (worldHealthReference == null)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] WorldHealth引用为空，无法测试碰撞检测");
            }
            return;
        }
        
        // 强制将贴图移动到玩家位置附近进行测试
        Vector3 playerPosition = Networking.LocalPlayer.GetPosition();
        Vector3 testPosition = playerPosition + Vector3.forward * (textureCollisionRadius * 0.5f);
        movingTexture.transform.position = testPosition;
        
        if (enableDebugLog)
        {
            Debug.Log($"[Icarus] 已将贴图移动到测试位置: {testPosition}");
            Debug.Log($"[Icarus] 玩家位置: {playerPosition}");
            Debug.Log($"[Icarus] 预期距离: {textureCollisionRadius * 0.5f:F2}m");
        }
        
        // 手动触发碰撞检测
        CheckPlayerCollision();
        
        if (enableDebugLog)
        {
            Debug.Log("=== 碰撞检测测试完成 ===");
        }
    }
    
    /// <summary>
    /// 强制触发碰撞（可在Inspector中调用）
    /// </summary>
    [ContextMenu("强制触发碰撞")]
    public void ForceTriggerCollision()
    {
        if (enableDebugLog)
        {
            Debug.Log("=== 强制触发碰撞测试 ===");
        }
        
        if (worldHealthReference == null)
        {
            if (enableDebugLog)
            {
                Debug.LogError("[Icarus] WorldHealth引用为空，无法测试");
            }
            return;
        }
        
        // 直接调用WorldHealth的伤害方法
        worldHealthReference.InstantlyKillPlayer();
        
        if (enableDebugLog)
        {
            Debug.LogWarning("[Icarus] 已强制调用WorldHealth.InstantlyKillPlayer()方法");
        }
    }
    
    /// <summary>
    /// 监控贴图移动启动过程（可在Inspector中调用）
    /// </summary>
    [ContextMenu("监控贴图移动启动过程")]
    public void MonitorTextureMovementStart()
    {
        if (enableDebugLog)
        {
            Debug.Log("=== 贴图移动启动监控 ===");
            Debug.Log($"当前时间: {Time.time:F2}秒");
            Debug.Log($"红色灯光激活: {isRedLightActive}");
            Debug.Log($"贴图开始标记: {isTextureStarted}");
            Debug.Log($"贴图移动状态: {isTextureMoving}");
            
            if (isRedLightActive)
            {
                float elapsedRedLightTime = Time.time - redLightStartTime;
                float textureStartTime = redLightDuration - 1f;
                float timeUntilTextureStart = textureStartTime - elapsedRedLightTime;
                
                Debug.Log($"红色灯光已运行: {elapsedRedLightTime:F2}秒");
                Debug.Log($"贴图启动时间点: {textureStartTime:F2}秒");
                Debug.Log($"距离贴图启动还有: {timeUntilTextureStart:F2}秒");
                Debug.Log($"是否已过启动时间点: {(elapsedRedLightTime >= textureStartTime ? "是" : "否")}");
                Debug.Log($"是否在启动时间窗口内: {(elapsedRedLightTime >= textureStartTime && elapsedRedLightTime < textureStartTime + 0.1f ? "是" : "否")}");
            }
            else
            {
                Debug.Log("红色灯光未激活，无法监控贴图移动启动");
            }
        }
    }
    
    /// <summary>
    /// 诊断光源闪烁问题（可在Inspector中调用）
    /// </summary>
    [ContextMenu("诊断光源闪烁问题")]
    public void DiagnoseLightFlashingIssues()
    {
        if (enableDebugLog)
        {
            Debug.Log("=== 光源闪烁问题诊断 ===");
            Debug.Log($"初始化状态: {isInitialized}");
            Debug.Log($"总体闪烁状态: {isFlashing}");
            int targetLightsLength = targetLights != null ? targetLights.Length : 0;
            int lightFlashingStatesLength = lightFlashingStates != null ? lightFlashingStates.Length : 0;
            int lightFlashStartTimesLength = lightFlashStartTimes != null ? lightFlashStartTimes.Length : 0;
            int lightFlashDurationsLength = lightFlashDurations != null ? lightFlashDurations.Length : 0;
            int originalIntensitiesLength = originalIntensities != null ? originalIntensities.Length : 0;
            int originalColorsLength = originalColors != null ? originalColors.Length : 0;
            
            Debug.Log($"光源数组长度: {targetLightsLength}");
            
            // 检查数组状态
            Debug.Log($"lightFlashingStates长度: {lightFlashingStatesLength}");
            Debug.Log($"lightFlashStartTimes长度: {lightFlashStartTimesLength}");
            Debug.Log($"lightFlashDurations长度: {lightFlashDurationsLength}");
            Debug.Log($"originalIntensities长度: {originalIntensitiesLength}");
            Debug.Log($"originalColors长度: {originalColorsLength}");
            
            // 检查每个光源的状态
            if (targetLights != null)
            {
                for (int i = 0; i < targetLights.Length; i++)
                {
                    string lightStatus = targetLights[i] != null ? "有效" : "null";
                    string flashingStatus = "";
                    string intensityInfo = "";
                    
                    if (i < lightFlashingStates.Length)
                    {
                        flashingStatus = lightFlashingStates[i] ? "闪烁中" : "空闲";
                    }
                    else
                    {
                        flashingStatus = "数组越界";
                    }
                    
                    if (i < originalIntensities.Length && targetLights[i] != null)
                    {
                        intensityInfo = $", 原始强度: {originalIntensities[i]:F2}, 当前强度: {targetLights[i].intensity:F2}";
                    }
                    
                    Debug.Log($"光源 {i}: {lightStatus}, 闪烁状态: {flashingStatus}{intensityInfo}");
                }
            }
            
            // 检查数组长度匹配
            bool arraysMatch = (lightFlashingStatesLength == targetLightsLength) &&
                              (lightFlashStartTimesLength == targetLightsLength) &&
                              (lightFlashDurationsLength == targetLightsLength) &&
                              (originalIntensitiesLength == targetLightsLength) &&
                              (originalColorsLength == targetLightsLength);
            
            Debug.Log($"数组长度匹配: {(arraysMatch ? "是" : "否")}");
            
            if (!arraysMatch)
            {
                Debug.LogWarning("[Icarus] 检测到数组长度不匹配，这可能导致某些光源不闪烁！");
            }
        }
    }
    

}
